.TH std::experimental::boyer_moore_horspool_searcher, 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::boyer_moore_horspool_searcher, \- std::experimental::boyer_moore_horspool_searcher,

.SH Synopsis

   Defined in header <experimental/functional>
   template< class RandomIt1,

             class Hash = std::hash<typename                          (library
   std::iterator_traits<RandomIt1>::value_type>,                      fundamentals TS)
             class BinaryPredicate = std::equal_to<> >

   class boyer_moore_horspool_searcher;

   A searcher suitable for use with std::experimental::search that implements the
   Boyer-Moore-Horspool string searching algorithm.

   boyer_moore_horspool_searcher is CopyConstructible and CopyAssignable.

   RandomIt1 must meet the requirements of LegacyRandomAccessIterator.

.SH Member functions

std::experimental::boyer_moore_horspool_searcher::boyer_moore_horspool_searcher

   boyer_moore_horspool_searcher( RandomIt1 pat_first,

                                  RandomIt1 pat_last,
                                  Hash hf = Hash(),

                                  BinaryPredicate pred = BinaryPredicate() );

   Constructs a boyer_moore_horspool_searcher by storing copies of pat_first, pat_last,
   hf, and pred, setting up any necessary internal data structures.

   The value type of RandomIt1 must be DefaultConstructible, CopyConstructible and
   CopyAssignable.

   For any two values A and B of the type std::iterator_traits<RandomIt1>::value_type,
   if pred(A, B) == true, then hf(A) == hf(B) shall be true.

.SH Parameters

   pat_first, pat_last - a pair of iterators designating the string to be searched for
   hf                  - a callable object used to hash the elements of the string
   pred                - a callable object used to determine equality

.SH Exceptions

   Any exceptions thrown by

     * the copy constructor of RandomIt1;
     * the default constructor, copy constructor, or copy assignment operator of the
       value type of RandomIt1; or
     * the copy constructor or function call operator of BinaryPredicate or Hash.

   May also throw std::bad_alloc if additional memory required for internal data
   structures cannot be allocated.

std::experimental::boyer_moore_horspool_searcher::operator()

   template< class RandomIt2 >                                            \fI(until C++17)\fP
   RandomIt2 operator()( RandomIt2 first, RandomIt2 last ) const;
   template< class RandomIt2 >
   std::pair<RandomIt2,RandomIt2> operator()( RandomIt2 first, RandomIt2  \fI(since C++17)\fP
   last ) const;

   The member function called by std::experimental::search to perform a search with
   this searcher. RandomIt2 must meet the requirements of LegacyRandomAccessIterator.

   RandomIt1 and RandomIt2 must have the same value type.

.SH Parameters

   first, last - a pair of iterators designating the string to be examined

.SH Return value

   If the pattern [pat_first, pat_last) is empty, returns first.

   Otherwise, an iterator to the first position in [first, last) where a  \fI(until C++17)\fP
   subsequence that compares equal to [pat_first, pat_last) as defined by
   pred is located, or a copy of last otherwise.
   If the pattern [pat_first, pat_last) is empty, returns
   make_pair(first, first).

   Otherwise, returns a pair of iterators to the first and one past last  \fI(since C++17)\fP
   positions in [first, last) where a subsequence that compares equal to
   [pat_first, pat_last) as defined by pred is located, or
   make_pair(last, last) otherwise.

   Helper Functions

   template< class RandomIt,

             class Hash = std::hash<typename
   std::iterator_traits<RandomIt>::value_type>,
             class BinaryPredicate = std::equal_to<> >
   boyer_moore_horspool_searcher<RandomIt, Hash, BinaryPredicate>     (library
       make_boyer_moore_horspool_searcher( RandomIt pat_first,        fundamentals TS)
                                           RandomIt pat_last,
                                           Hash hf = Hash(),

                                           BinaryPredicate pred =
   BinaryPredicate() );

   Helper function that constructs a std::experimental::boyer_moore_horspool_searcher
   using template argument deduction. Equivalent to return
   boyer_moore_horspool_searcher<RandomIt, Hash, BinaryPredicate>(pat_first, pat_last,
   hf, pred);

.SH Parameters

   pat_first, pat_last - a pair of iterators designating the string to be searched for
   hf                  - a callable object used to hash the elements of the string
   pred                - a callable object used to determine equality

.SH Return value

   A boyer_moore_horspool_searcher constructed with the arguments pat_first, pat_last,
   hf, and pred.

.SH Example


// Run this code

 #include <experimental/algorithm>
 #include <experimental/functional>
 #include <iostream>
 #include <string>

 int main()
 {
     std::string in = "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
                      " sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
     std::string needle = "pisci";
     auto it = std::experimental::search(in.begin(), in.end(),
                   std::experimental::make_boyer_moore_horspool_searcher(
                       needle.begin(), needle.end()));
     if (it != in.end())
         std::cout << "The string " << needle << " found at offset "
                   << it - in.begin() << '\\n';
     else
         std::cout << "The string " << needle << " not found\\n";
 }

.SH Output:

 The string pisci found at offset 43

.SH See also

   search searches for a range of elements
          \fI(function template)\fP

.SH Category:
     * Noindexed pages
